#include "supplier.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h> // For directory creation check/mkdir

// 包含目录创建辅助函数（假设 Windows 使用 _mkdir，如果需要请调整）
#ifdef _WIN32
#include <direct.h>
#define MKDIR(path) _mkdir(path)
#else
#include <unistd.h> // For POSIX mkdir
#define MKDIR(path) mkdir(path, 0755) // 0755 permissions
#endif

// --- 文件格式 ---
// data/suppliers.dat
// 纯文本文件，每行一个供应商。
// 字段之间用 '|' 分隔。换行符 '\n' 分隔记录。
// 格式：id|名称|联系人|电话|地址\n
// 重要提示：假设字段不包含 '|' 或 '\n'。

// --- 辅助函数 ---

// (从 component.c 复制，为供应商稍作调整)
// 创建一个新的 SupplierNode（不添加到列表）
static SupplierNode* create_supplier_node(const Supplier* data) {
    SupplierNode* newNode = (SupplierNode*)malloc(sizeof(SupplierNode));
    if (!newNode) {
        perror("Failed to allocate memory for SupplierNode");
        return NULL;
    }
    newNode->data = *data; // Copy data
    newNode->next = NULL;
    return newNode;
}

// (从 component.c 复制，稍作调整)
// 递归创建文件路径的父目录的工具函数。
// 只在 'data' 目录内或包含 'data' 目录创建目录。
// 成功或无需创建返回0，错误或无效路径返回-1。
static int create_parent_directories(const char* filepath) {
    if (!filepath) return -1;

    char buf[512]; // Buffer for path manipulation
    strncpy(buf, filepath, sizeof(buf) - 1);
    buf[sizeof(buf) - 1] = '\0';

    // 查找最后一个路径分隔符
    char* last_sep = NULL;
    for (char* p = buf; *p; ++p) {
        if (*p == '/' || *p == '\\') {
            last_sep = p;
        }
    }

    // 如果未找到分隔符，则只是当前目录中的文件名，无需父目录。
    if (!last_sep) return 0;

    // 临时终止最后一个分隔符处的字符串以获取父路径
    *last_sep = '\0';

    // 安全检查：只允许在 'data' 目录内或 'data' 本身创建
    if (strcmp(buf, "data") == 0 || strcmp(buf, "data\\") == 0 || strcmp(buf, "data/") == 0) {
        // 它是 'data' 目录本身，尝试创建它（可能已存在）
        MKDIR(buf); // Ignore error if it already exists
        return 0;
    } else if (strncmp(buf, "data/", 5) == 0 || strncmp(buf, "data\\", 5) == 0) {
        // 它是 'data' 内的子目录，先递归创建其父目录
        int result = create_parent_directories(buf); // Recursive call for the parent path
        if (result != 0) {
            // 创建父目录失败，因此也无法创建此目录
            return -1;
        }
        // 现在尝试创建当前目录
        MKDIR(buf); // Ignore error if it already exists
        return 0;
    } else {
        // 路径超出允许的 'data' 范围
        fprintf(stderr, "Error: Attempted to create directory outside 'data': %s\n", buf);
        return -1;
    }
}


// --- 核心函数 ---

// 从文件加载供应商到链表。
int load_suppliers(const char* filename, SupplierNode** head) {
    FILE* file = fopen("d:/GITEE/Component-Information-Management-System/data/suppliers.dat", "r");
    if (!file) {
        *head = NULL; // Ensure list is empty if file doesn't exist
        return 0;
    }

    *head = NULL;
    SupplierNode* tail = NULL;
    int count = 0;
    char line[1024]; // Buffer for reading lines

    while (fgets(line, sizeof(line), file)) {
        line[strcspn(line, "\n")] = 0; // Remove trailing newline

        Supplier supp_data;
        memset(&supp_data, 0, sizeof(Supplier)); // Initialize struct

        // 使用 strtok 解析行（简单解析）
        char* token;
        int field_index = 0;
        token = strtok(line, "|");
        while (token != NULL && field_index < 5) {
            switch (field_index) {
                case 0: supp_data.id = atoi(token); break;
                case 1: strncpy(supp_data.name, token, SUPPLIER_NAME_LEN - 1); break;
                case 2: strncpy(supp_data.contact_person, token, SUPPLIER_CONTACT_LEN - 1); break;
                case 3: strncpy(supp_data.phone, token, SUPPLIER_PHONE_LEN - 1); break;
                case 4: strncpy(supp_data.address, token, SUPPLIER_ADDRESS_LEN - 1); break;
            }
            token = strtok(NULL, "|");
            field_index++;
        }

        // 基本验证
        if (field_index >= 5) {
            SupplierNode* newNode = create_supplier_node(&supp_data);
            if (newNode) {
                if (*head == NULL) {
                    *head = newNode;
                    tail = newNode;
                } else {
                    tail->next = newNode;
                    tail = newNode;
                }
                count++;
            } else {
                 fprintf(stderr, "Error: Failed to allocate memory for supplier ID %d\n", supp_data.id);
            }
        } else {
             fprintf(stderr, "Warning: Skipping malformed line in %s: %s\n", filename, line);
        }
    }

    fclose(file);
    printf("Loaded %d suppliers from %s\n", count, filename);
    return count;
}

// 将链表中的供应商保存到文件。
int save_suppliers(const char* filename, SupplierNode* head) {
    // 确保父目录存在
    if (create_parent_directories(filename) != 0) {
        fprintf(stderr, "Error: Failed to create parent directory for %s\n", filename);
        return 0; // Indicate failure
    }

    FILE* file = fopen("d:/GITEE/Component-Information-Management-System/data/suppliers.dat", "w");
    if (!file) {
        perror("Failed to open supplier file for writing");
        return 0;
    }

    SupplierNode* current = head;
    int count = 0;
    while (current != NULL) {
        // 格式：id|名称|联系人|电话|地址\n
        int written = fprintf(file, "%d|%s|%s|%s|%s\n",
                              current->data.id,
                              current->data.name,
                              current->data.contact_person,
                              current->data.phone,
                              current->data.address);

        if (written < 0) {
            perror("Failed to write supplier data to file");
            fclose(file);
            return count; // Return number saved before error
        }
        current = current->next;
        count++;
    }

    fclose(file);
    printf("Saved %d suppliers to %s\n", count, filename);
    return count;
}

// 释放供应商链表分配的内存。
void free_all_suppliers(SupplierNode* head) {
    SupplierNode* current = head;
    SupplierNode* next_node;
    int count = 0;
    while (current != NULL) {
        next_node = current->next;
        free(current);
        current = next_node;
        count++;
    }
     printf("Freed %d supplier nodes.\n", count);
}

// 向链表中添加新供应商。成功返回1，ID已存在或出错返回0。
int add_supplier(SupplierNode** head, const Supplier* new_supplier) {
     if (!head || !new_supplier) return 0;

    // 检查ID是否已存在
    SupplierNode* current = *head;
    while (current) {
        if (current->data.id == new_supplier->id) {
            fprintf(stderr, "Error: Supplier ID %d already exists.\n", new_supplier->id);
            return 0; // ID exists
        }
        current = current->next;
    }

    // 创建新节点并添加到列表开头
    SupplierNode* newNode = create_supplier_node(new_supplier);
    if (!newNode) {
        return 0; // Memory allocation failed
    }
    newNode->next = *head;
    *head = newNode;
    printf("Added supplier with ID: %d\n", new_supplier->id);
    return 1; // Success
}

// 从链表中删除指定ID的供应商。成功返回1，未找到返回0。
int delete_supplier(SupplierNode** head, int supplier_id) {
    if (!head || !*head) return 0; // Empty list or invalid head pointer

    SupplierNode* current = *head;
    SupplierNode* prev = NULL;

    while (current != NULL) {
        if (current->data.id == supplier_id) {
            // 找到要删除的节点
            if (prev == NULL) {
                // 删除头节点
                *head = current->next;
            } else {
                // 删除中间或末尾的节点
                prev->next = current->next;
            }
            free(current); // Free the memory
            printf("Deleted supplier with ID: %d\n", supplier_id);
            return 1; // Success
        }
        // 移动到下一个节点
        prev = current;
        current = current->next;
    }

    fprintf(stderr, "Error: Supplier ID %d not found for deletion.\n", supplier_id);
    return 0; // Not found
}

// 按ID查找供应商。找到返回节点指针，否则返回NULL。
SupplierNode* find_supplier_by_id(SupplierNode* head, int supplier_id) {
    SupplierNode* current = head;
    while (current != NULL) {
        if (current->data.id == supplier_id) {
            return current; // Found
        }
        current = current->next;
    }
    return NULL; // Not found
}

// 更新现有供应商的信息。成功返回1，未找到或出错返回0。
int update_supplier(SupplierNode* head, const Supplier* updated_supplier) {
    if (!updated_supplier) return 0;

    SupplierNode* nodeToUpdate = find_supplier_by_id(head, updated_supplier->id);
    if (nodeToUpdate) {
        // 找到节点，更新其数据
        nodeToUpdate->data = *updated_supplier; // Direct struct copy
        printf("Updated supplier with ID: %d\n", updated_supplier->id);
        return 1; // Success
    } else {
        fprintf(stderr, "Error: Supplier ID %d not found for update.\n", updated_supplier->id);
        return 0; // Not found
    }
}

// --- 数据验证函数实现 ---

#include <ctype.h>

// 验证供应商ID：纯数字，1-6位
int validate_supplier_id_field(int id) {
    return (id > 0 && id <= 999999); // 1-6位数字
}

// 验证供应商名称：中英文，1-50字符，拒绝特殊符号（空格除外）
int validate_supplier_name(const char* name) {
    if (!name || strlen(name) < 1 || strlen(name) > 50) {
        return 0;
    }
    
    int has_valid_char = 0;
    for (int i = 0; name[i]; i++) {
        char c = name[i];
        // 允许字母、数字、空格和中文字符（UTF-8）
        if (isalnum(c) || c == ' ') {
            has_valid_char = 1;
        } else if ((unsigned char)c >= 0x80) {
            // 可能是UTF-8多字节字符（中文等），允许
            has_valid_char = 1;
        } else {
            // 其他特殊符号不允许
            return 0;
        }
    }
    
    // 确保不是纯空格
    return has_valid_char;
}

// 验证联系人：中英文，1-30字符，拒绝特殊符号（空格除外）
int validate_supplier_contact(const char* contact) {
    if (!contact || strlen(contact) < 1 || strlen(contact) > 30) {
        return 0;
    }
    
    int has_valid_char = 0;
    for (int i = 0; contact[i]; i++) {
        char c = contact[i];
        // 允许字母、数字、空格和中文字符（UTF-8）
        if (isalnum(c) || c == ' ') {
            has_valid_char = 1;
        } else if ((unsigned char)c >= 0x80) {
            // 可能是UTF-8多字节字符（中文等），允许
            has_valid_char = 1;
        } else {
            // 其他特殊符号不允许
            return 0;
        }
    }
    
    return has_valid_char;
}

// 验证电话：数字、连字符、空格、括号，最多20字符
int validate_supplier_phone(const char* phone) {
    if (!phone || strlen(phone) > 20) {
        return 0;
    }
    
    // 允许空电话号码
    if (strlen(phone) == 0) {
        return 1;
    }
    
    for (int i = 0; phone[i]; i++) {
        char c = phone[i];
        // 只允许数字、连字符、空格、括号、加号
        if (!isdigit(c) && c != '-' && c != ' ' && c != '(' && c != ')' && c != '+') {
            return 0;
        }
    }
    return 1;
}

// 验证地址：中英文+数字，最大100字符，拒绝恶意脚本
int validate_supplier_address(const char* address) {
    if (!address) {
        return 1; // 可选字段，NULL也允许
    }
    
    int len = strlen(address);
    if (len > 100) {
        return 0;
    }
    
    // 允许空地址
    if (len == 0) {
        return 1;
    }
    
    // 检查是否包含恶意脚本标签
    if (strstr(address, "<script") || strstr(address, "</script") ||
        strstr(address, "<iframe") || strstr(address, "<object") ||
        strstr(address, "javascript:") || strstr(address, "vbscript:")) {
        return 0;
    }
    
    return 1;
}

// 完整验证供应商数据
int validate_supplier_data(const Supplier* supplier, char* error_msg, int error_msg_size) {
    if (!supplier || !error_msg) {
        return 0;
    }
    
    memset(error_msg, 0, error_msg_size);
    
    if (!validate_supplier_id_field(supplier->id)) {
        snprintf(error_msg, error_msg_size, "供应商ID必须是1-6位的正整数");
        return 0;
    }
    
    if (!validate_supplier_name(supplier->name)) {
        snprintf(error_msg, error_msg_size, "供应商名称必须是1-50个字符，支持英文和数字，不能有特殊符号（空格除外）");
        return 0;
    }
    
    if (!validate_supplier_contact(supplier->contact_person)) {
        snprintf(error_msg, error_msg_size, "联系人必须是1-30个字符，支持英文和数字，不能有特殊符号（空格除外）");
        return 0;
    }
    
    if (!validate_supplier_phone(supplier->phone)) {
        snprintf(error_msg, error_msg_size, "电话号码最多20个字符，只能包含数字、连字符、空格、括号和加号");
        return 0;
    }
    
    if (!validate_supplier_address(supplier->address)) {
        snprintf(error_msg, error_msg_size, "地址不能超过100个字符，且不能包含恶意脚本标签");
        return 0;
    }
    
    return 1;
}